JavaScript
part 17/19 · 71.4 KB total
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
Le code de l'opérateur instanceOf illustre bien ce mécanisme. A instanceOf B (ou de manière équivalente : instanceOf.call(A, B)) renvoie true si A est une instance de B, c'est-à-dire si B.prototype est trouvé dans le chaîne de prototypes de A, et false sinon :
function instanceOf(f) {
let o = this;
while (o !== null) {
o = Object.getPrototypeOf(o);
if (o === f.prototype) {
return true;
}
}
return false;
}
Par ailleurs, la méthode Object.create introduite dans ECMAScript 5 permet d'éviter d'utiliser directement les fonctions constructeurs, leurs propriétés prototype et l'opérateur new, pour ne travailler qu'avec des objets. L'utilisation de cette méthode simplifie grandement la complexité du code et est donc recommandée. La méthode Object.create est définie par
if (typeof Object.create !== 'function') {
Object.create = function (o) {
function F() {}
F.prototype = o;
return new F();
};
}
L'exemple précédent peut alors être réécrit
const MonObjet = {
function initialiser() {
this.maPropriete1 = 3;
}
}
const monInstance = Object.create(MonObjet);
monInstance.initialiser();
alert(monInstance.maPropriete1); // affiche 3
MonObjet.maPropriete2 = 5;
alert(monInstance.maPropriete2); // affiche 5
Séparation des instructions
En C, chaque instruction se termine par un point-virgule. Cette pratique a fait du point-virgule une obligation dans de nombreux langages inspirés de la syntaxe du C.
JavaScript est plus souple, permettant à une fin de ligne de marquer implicitement la fin d'une instruction. Le but est de faciliter l'usage du langage aux personnes inexpérimentées en programmation informatique. Mais cette souplesse introduit des effets inattenduscite-ref-32[32] :
return
true;
Le parseur comprend cela comme deux instructions :
return;
true;
Les expressions de fonctions immédiatement invoquées lorsque le programmeur s'appuie sur les fins d'instruction implicites rencontrent également ce genre de problème avec l'usage des parenthèses :
maVariable1 = maVariable2 + maVariable3
(function () {
// code
})()
est traité comme
maVariable1 = maVariable2 + maVariable3(function () { /* code */ })();
Les ouvrages de programmation avancés en JavaScript mettent en garde contre les effets inattendus de la déduction automatique de fin d'instruction et conseillent d'écrire un point-virgule à la fin de chaque instruction, ce qui n'empêche pas les surprises lorsqu'on oublie le point-virgule, d'autant plus quand la compression du code impose le retrait des retours chariot.
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────